#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include "y.tab.h"
#include "ts2006.h"
#include "sint.h"


extern int inserta_ts(int, char *);
extern int tabla_simbolos[MAX];
extern int encuentra_en_ts(char *id);
int yyerror(char *);



int inserta_ts_desp (int ts, char* lexema, char* tipo, char * clase) {
  short int valor         = 0;
  short int desp          = 0;
  short int tam_necesario = 1;
  int cima_tmp            = 0;
  short int tam_calculado = 0;
  char tipo_basico[MAX];
  char tipo_basico_swap[MAX];
  //Comprobacion de que el identificador no existe ya
  if((valor=existe_entrada(ts, lexema))==0) {
    yyerror("Identificador ya declarado");
    return (-1);
  } else if(valor==1){
    //Insertamos el identificador en la tabla de simbolos creada ( nuevo ambito )
    inserta_ts(ts, lexema);
    //  clase = variable o parametro
    if(asignar_tipo_entrada(ts, lexema, clase)<0) {
      fprintf(stdout,"Error al anyadir el tipo de entrada\n");
      exit(-1); 
    }
    //  Tendremos que darle valor al desplazamiento de este tipo
    desp = consultar_valor_atributo_entero(ts, "desplazamiento_maximo", "valor");
    //  tipo  = integer, boolean, ... (luego tendremos que ir buscando el tipo)
    memset (tipo_basico, 0, MAX*sizeof(char));
    strncat(tipo_basico, tipo, MAX);
    while (!tam_calculado) {
      if (strncmp(tipo_basico, "integer", 7) == 0) {
        tam_necesario = desp_integer * tam_necesario;
        tam_calculado = 1;
      } else if (strncmp(tipo_basico, "boolean", 7) == 0) {
        tam_necesario = desp_boolean * tam_necesario;
        tam_calculado = 1;
      }  else {  // No lo se
        cima_tmp = encuentra_en_ts(tipo_basico);
        memset (tipo_basico_swap, 0, MAX*sizeof(char));
        strncat(tipo_basico_swap,
                consultar_valor_atributo_cadena (tabla_simbolos[cima_tmp],
                                                 tipo_basico, "tipo"),
                MAX);
        memset (tipo_basico, 0, MAX*sizeof(char));
        strncat(tipo_basico, tipo_basico_swap, MAX);
        tam_necesario =
          (consultar_valor_atributo_entero (ts, tipo, "max") -
           consultar_valor_atributo_entero (ts, tipo, "min") + 1) * tam_necesario;
      }
    }
    //Anyadimos el tipo de valores que contiene y el valor maximo del rango
    //tipo viene recursivamente del final
    if(crear_atributo_cadena(ts, lexema, "tipo", tipo_basico)<0) {
      fprintf(stdout,"Error al crear un atributo de tipo cadena\n");
      exit(-1);
    }

    if(crear_atributo_entero(ts, lexema, "desplazamiento", desp)<0) {
      fprintf(stdout,"Error al crear un atributo de tipo entero\n");
      exit(-1);
    }
    desp += tam_necesario;
    if (asignar_valor_atributo_entero(ts, "desplazamiento_maximo", "valor", desp) != 0) {
      fprintf(stdout,"Fallo al actualizar el desplazamiento_maximo\n");
      exit(-1);
    }
    return 0;
  } else {
    fprintf(stdout,"Error %s\n", consultar_descripcion_ultimo_error());
    exit(-1);
  }
}
